//!
//! 代码


//! 测试用例
//! 测试结果
//! 测试结果
//! 2. 两数相加
//! 已解答
//! 中等
//! 相关标签
//! 相关企业
//! 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

//! 请你将两个数相加，并以相同形式返回一个表示和的链表。

//! 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
//! 


struct Solution;

impl Solution {
    /// 解决思路是，从左到右，从上到下，按位计算每一位
    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
        let mut carry = 0;
        let mut dummy_head = Box::new(ListNode::new(0));
        let mut current = &mut dummy_head;

        let mut l1 = l1;
        let mut l2 = l2;

        while l1.is_some() || l2.is_some() || carry > 0 {
            let sum = l1.as_ref().map_or(0, |node| node.val) + l2.as_ref().map_or(0, |node| node.val) + carry;
            carry = sum / 10;
            current.next = Some(Box::new(ListNode::new(sum % 10)));
            current = current.next.as_mut().unwrap();

            l1 = l1.and_then(|node| node.next);
            l2 = l2.and_then(|node| node.next);
        }

        dummy_head.next
    }
}

fn add_two_numbers2(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>, carray: i32) 
        -> (i32, Option<Box<ListNode>>, Option<Box<ListNode>>  )
{
    if l1.is_none() && l2.is_none() && 0 == carray {
        return (0, None, None);
    }

    let mut node1 = None;
    let mut node2 = None;

    let mut n1 = 0;
    let mut n2 = 0;
    if let Some(e) = l1 {
        n1 = e.val;
        node1 = e.next;
    }
    if let Some(e) = l2 {
        n2 = e.val;
        node2 = e.next;
    }
    return (n1 + n2 + carray, node1, node2);
}

#[derive(PartialEq, Eq, Clone, Debug)]
pub struct ListNode {
  pub val: i32,
  pub next: Option<Box<ListNode>>
}

impl ListNode {
  #[inline]
  fn new(val: i32) -> Self {
    ListNode {
      next: None,
      val
    }
  }
}